/*
备忘录模式（Memento Pattern）是一种行为型设计模式，它允许在不破坏封装性的前提下捕获一个对象的内部状态，并在稍后将该状态恢复到原先的状态。
备忘录模式通过将对象的状态封装到备忘录对象中，从而实现了对象状态的保存和恢复。

在备忘录模式中，通常会有三个角色：

1. 发起人（Originator）：负责创建备忘录对象，并将自身状态保存到备忘录对象中。
2. 备忘录（Memento）：用于存储发起人对象的状态。备忘录对象可以由发起人创建，也可以由其他对象创建。
3. 管理者（Caretaker）：负责保存备忘录对象，并在需要时将备忘录对象恢复到原先的状态。

下面是一个使用备忘录模式的C语言例程：
*/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// 备忘录接口
typedef struct {
    char *state;
} Memento;

Memento *createMemento(const char *state) {
    Memento *memento = (Memento *)malloc(sizeof(Memento));
    memento->state = (char *)malloc(strlen(state) + 1);
    strcpy(memento->state, state);
    return memento;
}

void destroyMemento(Memento *memento) {
    free(memento->state);
    free(memento);
}

// 发起人
typedef struct {
    char *state;
} Originator;

void setState(Originator *originator, const char *state) {
    originator->state = (char *)malloc(strlen(state) + 1);
    strcpy(originator->state, state);
}

void printState(Originator *originator) {
    printf("Current state: %s\n", originator->state);
}

Memento *createMementoFromState(Originator *originator) {
    return createMemento(originator->state);
}

void setStateFromMemento(Originator *originator, Memento *memento) {
    originator->state = (char *)malloc(strlen(memento->state) + 1);
    strcpy(originator->state, memento->state);
}

void destroyState(Originator *originator) {
    free(originator->state);
}

// 管理者
typedef struct {
    Memento *memento;
} Caretaker;

void saveMemento(Caretaker *caretaker, Memento *memento) {
    caretaker->memento = memento;
}

Memento *getMemento(Caretaker *caretaker) {
    return caretaker->memento;
}

void destroyCaretaker(Caretaker *caretaker) {
    destroyMemento(caretaker->memento);
}

int main() {
    Originator *originator = (Originator *)malloc(sizeof(Originator));
    setState(originator, "State 1");
    printState(originator);

    Memento *memento = createMementoFromState(originator);

    setState(originator, "State 2");
    printState(originator);

    setStateFromMemento(originator, memento);
    printState(originator);

    destroyState(originator);
    destroyMemento(memento);
    free(originator);

    return 0;
}

/*
在上面的例程中，首先定义了备忘录接口Memento，其中包含了保存和获取状态的方法。
然后，定义了发起人Originator，它负责保存和恢复状态。
在createMementoFromState函数中，通过发起人的状态创建了备忘录对象。
在setStateFromMemento函数中，通过备忘录对象恢复了发起人的状态。
接下来，定义了管理者Caretaker，它负责保存备忘录对象。
在saveMemento函数中，保存了备忘录对象。
在getMemento函数中，获取了备忘录对象。
最后，在main函数中，创建了发起人对象和备忘录对象，并通过发起人对象保存和恢复了状态。

通过使用备忘录模式，我们可以在不破坏对象封装性的前提下，保存和恢复对象的状态。
备忘录模式可以增加系统的灵活性和可维护性，因为状态的保存和恢复被封装在备忘录对象中，而不会影响到其他对象。
同时，备忘录模式也可以用于实现撤销和恢复操作，因为可以保存多个备忘录对象，从而可以在需要时恢复到不同的状态。
*/